home *** CD-ROM | disk | FTP | other *** search
/ Aminet 24 / Aminet 24 (1998)(GTI - Schatztruhe)[!][Apr 1998].iso / Aminet / dev / c / chunky.lha / lib_chunky / tst-src / test1.c < prev    next >
C/C++ Source or Header  |  1998-02-26  |  7KB  |  374 lines
  1. /*
  2. ** test.c
  3. **
  4. ** Tests the various gfx functions and prints the execution time
  5. **
  6. ** compile me with
  7. ** gcc -noixemul -s -m68020 -O2 -o test test.c -lchunky -lm
  8. */
  9. #define __CONSTLIBBASEDECL__  const
  10. #include  <exec/execbase.h>
  11. #include  <intuition/screens.h>
  12. #include  <graphics/gfx.h>
  13. #include  <hardware/custom.h>
  14. #include  <hardware/cia.h>
  15. #include  <hardware/dmabits.h>
  16.  
  17. #include  <proto/exec.h>
  18. #include  <proto/intuition.h>
  19. #include  <proto/graphics.h>
  20.  
  21. #include  <stdlib.h>
  22. #include  <time.h>
  23.  
  24. #include  "../lib-src/chunky.h"
  25.  
  26. #ifndef __GNUC__
  27. extern  __far struct CIA    ciaa;
  28. extern  __far struct CIA    ciab;
  29. extern  __far struct Custom custom;
  30. #else
  31. extern struct CIA     ciaa;
  32. extern struct CIA     ciab;
  33. extern struct Custom  custom;
  34. #endif
  35.  
  36. #define SX  640
  37. #define SY  480
  38. #define CX  640
  39. #define CY  480
  40.  
  41. struct  Screen      *scr;
  42. struct  RastPort    *rp;
  43. struct  ChunkyPort  *cp;
  44.  
  45. /*///"Time functions"*/
  46. void PTimeStart( BOOL dmaoff )
  47. {
  48.     WaitTOF();
  49.     Forbid();
  50.     Disable();
  51.  
  52.     if( dmaoff )  custom.dmacon = DMAF_MASTER;
  53.  
  54.     ciab.ciacra = 0;      /* Timer a und b stoppen */
  55.     ciab.ciacrb = 0;
  56.  
  57.     ciab.ciatalo= 0xff;    /* TimerA = $ffff */
  58.     ciab.ciatahi= 0xff;
  59.  
  60.     ciab.ciatblo= 0xff;    /* TimerB = $ffff */
  61.     ciab.ciatbhi= 0xff;
  62.  
  63.     /* TimerB start mit INMODE1 set, da 32bit-Zähler */
  64.     ciab.ciacrb = CIACRBF_START|CIACRBF_INMODE1;
  65.  
  66.     /* TimerA start normal */
  67.     ciab.ciacra = CIACRAF_START;
  68.  
  69. }
  70.  
  71. ULONG PTimeStop( void )
  72. {
  73.     ULONG cycles;
  74.  
  75.     ciab.ciacra = 0;  /* Timer a und b stoppen */
  76.     ciab.ciacrb = 0;
  77.  
  78.     cycles =  0xffffffff -
  79.                         ( ( ciab.ciatalo ) + ( ciab.ciatahi * 0x100 ) +
  80.                             ( ciab.ciatblo * 0x10000 ) + ( ciab.ciatbhi * 0x1000000 ) );
  81.  
  82.     custom.dmacon = DMAF_SETCLR | DMAF_MASTER;
  83.  
  84.     Enable();
  85.     Permit();
  86.     return( cycles );
  87. }
  88.  
  89. void PPrintTime( char *head, ULONG val )
  90. {
  91.     struct ExecBase *sb = SysBase;
  92.     ULONG correct;
  93.     ULONG realtime;
  94.     ULONG etime = sb->ex_EClockFrequency;
  95.  
  96.     /* Calculate real time needed */
  97.     PTimeStart( 0 );
  98.     correct = PTimeStop();
  99.  
  100.     realtime = val - correct;
  101.  
  102.     printf( "Elapsed time for function %s: %f sec. \n", (LONG )head,
  103.     (float )((float )realtime/(float )etime ) );
  104. }
  105. /*///*/
  106. ///"Test functions"
  107. void lines1_chk( void )
  108. {
  109.     int i;
  110.     // vertical lines
  111.     PTimeStart( 0 );
  112.  
  113.     for( i = 0; i<CX; i++ ){
  114.         SetAPenChk( cp, i%255 );
  115.         LineChk( cp, i, 0, i, CY-1 );
  116.     }
  117.     PPrintTime( "v_lines_chk()", PTimeStop() );
  118.     DrawChunkyPort( cp, rp, 0, 0 );
  119.  
  120. }
  121. void lines2_chk( void )
  122. {
  123.     int i;
  124.     // horizontal lines
  125.     PTimeStart( 0 );
  126.  
  127.     for( i = 0; i<CY; i++ ){
  128.         SetAPenChk( cp, i%255 );
  129.         LineChk( cp, 0, i, CX-1, i );
  130.     }
  131.     PPrintTime( "h_lines_chk()", PTimeStop() );
  132.     DrawChunkyPort( cp, rp, 0, 0 );
  133.  
  134. }
  135. void lines3_chk( void )
  136. {
  137.     int i;
  138.     PTimeStart( 0 );
  139.     // lines spread
  140.     for( i = 0; i<CY; i++ ){
  141.         SetAPenChk( cp, i%255 );
  142.         LineChk( cp, 0, 0, CX-1, i );
  143.     }
  144.     PPrintTime( "s_lines_chk()", PTimeStop() );
  145.     DrawChunkyPort( cp, rp, 0, 0 );
  146. }
  147. void rect1_chk( void )
  148. {
  149.     // draw 256 filled boxes with random x/y-positions
  150.     int i;
  151.     int sx = 32;
  152.     int sy = 32;
  153.     int x, y;
  154.     srand( (unsigned )time(NULL));
  155.     PTimeStart(0);
  156.  
  157.     for( i= 0; i<256; i++ ){
  158.         SetAPenChk( cp, i%255);
  159.         sx= 4+ (rand() % 128);
  160.         sy= 4+ (rand() % 128);
  161.         x = rand() % (640-sx);
  162.         y = rand() % (480-sy);
  163.         RectFillChk( cp, x, y, x+sx, y+sy );
  164.     }
  165.     PPrintTime( "rect1_chk()", PTimeStop() );
  166.     DrawChunkyPort( cp, rp, 0, 0 );
  167.  
  168. }
  169.  
  170. void circle_chk( void )
  171. {
  172.     // draw 256 outlined circles with color fadeing
  173.     int i;
  174.     int sx = 64;
  175.     int sy = 64;
  176.     int x, y;
  177.  
  178.     srand( (unsigned )time(NULL));
  179.     PTimeStart(0);
  180.  
  181.     for( i= 0; i<256; i++ ){
  182.         SetAPenChk( cp, i%255);
  183.         x = sx+rand() % (640-(2*sx));
  184.         y = sy+rand() % (480-(2*sy));
  185.         DrawEllipseChk( cp, x, y, sx, sy );
  186.     }
  187.     PPrintTime( "circle_chk()", PTimeStop() );
  188.     DrawChunkyPort( cp, rp, 0, 0 );
  189. }
  190.  
  191. void setpix_chk( void )
  192. {
  193.     // draw 320*240 pixels
  194.     int i;
  195.     int sx = 64;
  196.     int sy = 64;
  197.     int x, y;
  198.  
  199.     srand( (unsigned )time(NULL));
  200.     PTimeStart(0);
  201.  
  202.     for( i= 0; i<CX/2*CY/2; i++ ){
  203.         x = rand() % 640;
  204.         y = rand() % 480;
  205.         SET_BYTE( cp, i%256, x, y );
  206.     }
  207.     PPrintTime( "writepixel_chk()", PTimeStop() );
  208.     DrawChunkyPort( cp, rp, 0, 0 );
  209. }
  210.  
  211. void lines1_rpt( void )
  212. {
  213.     int i;
  214.     // vertical lines
  215.     PTimeStart( 0 );
  216.     for( i = 0; i<CX; i++ ){
  217.         SetAPen( rp, i%255 );
  218.         Move( rp, i, 0 );
  219.         Draw( rp, i, CY-1 );
  220.     }
  221.     PPrintTime( "v_lines_rpt()", PTimeStop() );
  222. }
  223.  
  224. void lines2_rpt( void )
  225. {
  226.     int i;
  227.     // horizontal lines
  228.     PTimeStart( 0 );
  229.     for( i = 0; i<CY; i++ ){
  230.         SetAPen( rp, i%255 );
  231.         Move( rp, 0, i );
  232.         Draw( rp, CX-1, i );
  233.     }
  234.     PPrintTime( "h_lines_rpt()", PTimeStop() );
  235. }
  236.  
  237. void lines3_rpt( void )
  238. {
  239.     int i;
  240.     // lines-spread
  241.     PTimeStart( 0 );
  242.     for( i = 0; i<CY; i++ ){
  243.         SetAPen( rp, i%255 );
  244.         Move( rp, 0, 0 );
  245.         Draw( rp, CX-1, i );
  246.     }
  247.     PPrintTime( "s_lines_rpt()", PTimeStop() );
  248. }
  249.  
  250. void rect1_rpt( void )
  251. {
  252.     // draw 256 filled boxes with random x/y-positions
  253.     int i;
  254.     int sx = 32;
  255.     int sy = 32;
  256.     int x, y;
  257.  
  258.     srand( (unsigned )time(NULL));
  259.  
  260.     PTimeStart(0);
  261.  
  262.     for( i= 0; i<256; i++ ){
  263.         SetAPen( rp, i%255);
  264.         sx= 4+ (rand() % 128);
  265.         sy= 4+ (rand() % 128);
  266.         x = rand() % (640-sx);
  267.         y = rand() % (480-sy);
  268.         RectFill( rp, x, y, x+sx, y+sy );
  269.     }
  270.     PPrintTime( "rect1_rpt()", PTimeStop() );
  271. }
  272.  
  273. void circle_rpt( void )
  274. {
  275.     // draw 256 outlined circles with color fadeing
  276.     int i;
  277.     int sx = 64;
  278.     int sy = 64;
  279.     int x, y;
  280.     srand( (unsigned )time(NULL));
  281.     PTimeStart(0);
  282.  
  283.     for( i= 0; i<256; i++ ){
  284.         SetAPen( rp, i%255);
  285.         x = sx+rand() % (640-(2*sx));
  286.         y = sy+rand() % (480-(2*sy));
  287.         DrawEllipse( rp, x, y, sx, sy );
  288.     }
  289.     PPrintTime( "circle_rpt()", PTimeStop() );
  290. }
  291.  
  292. void setpix_rpt( void )
  293. {
  294.     // draw 320*240 pixels
  295.     int i;
  296.     int sx = 64;
  297.     int sy = 64;
  298.     int x, y;
  299.     srand( (unsigned )time(NULL));
  300.     PTimeStart(0);
  301.  
  302.     for( i= 0; i<CX/2*CY/2; i++ ){
  303.         SetAPen( rp, i%255);
  304.         x = rand() % 640;
  305.         y = rand() % 480;
  306.         WritePixel( rp, x, y );
  307.     }
  308.     PPrintTime( "writepixel_rpt()", PTimeStop() );
  309. }
  310.  
  311. void rpt_test( void )
  312. {
  313.     SetRast(rp, 0);
  314.     setpix_rpt();
  315.     SetRast(rp,0);
  316.     lines1_rpt();
  317.     SetRast(rp,0);
  318.     lines2_rpt();
  319.     SetRast(rp,0);
  320.     lines3_rpt();
  321.     SetRast(rp,0);
  322.     rect1_rpt();
  323.     SetRast(rp,0);
  324.     circle_rpt();
  325. }
  326.  
  327. void chk_test( void )
  328. {
  329.     setpix_chk();
  330.     ClearChunky(cp);
  331.     lines1_chk();
  332.     ClearChunky(cp);
  333.  
  334.     lines2_chk();
  335.     ClearChunky(cp);
  336.  
  337.     lines3_chk();
  338.     ClearChunky(cp);
  339.  
  340.     rect1_chk();
  341.     ClearChunky(cp);
  342.     circle_chk();
  343.     ClearChunky(cp);
  344.     Delay(100);
  345.     PTimeStart(0);
  346.     DrawChunkyPort(cp, rp, 0, 0 );
  347.     PPrintTime( "DrawChunkyPort()", PTimeStop() );
  348. }
  349. ///
  350. ///"main function"
  351. int main( void )
  352. {
  353.     if( scr = OpenScreenTags( NULL, SA_DisplayID, 0x39024,    // VGA: Productivity
  354.                                                                     SA_Width,     SX,
  355.                                                                     SA_Height,    SY,
  356.                                                                     SA_Depth,     8,
  357.                                                                     SA_Interleaved, TRUE,
  358.                                                                     TAG_DONE ) )
  359.     {
  360.         rp = &scr->RastPort;
  361.  
  362.         if( cp = InitChunkyPort( CX, CY ) )
  363.         {
  364.             /* Draw something */
  365.             chk_test();
  366.             rpt_test();
  367.             FreeChunkyPort( cp );
  368.         }
  369.         //Delay( 250 );
  370.         CloseScreen( scr );
  371.     }
  372. }
  373. ///
  374.